fix(cjs_wrap): flat-emit module.exports = <Class> that closes over a top-level binding (#4933) - #4947

Summary

Fixes #4933 — a compiled (compilePackages) CommonJS module whose default export is a class that reads a top-level const/let/var lost its entire method table: both static (Ctor.staticFn) and prototype (Ctor.prototype.method) methods read undefined on the consumer side, and new Ctor() threw whenever the constructor relied on one of those statics. This is the ink wall after #4902/#4931 — stack-utils → <ErrorOverview>:

import StackUtils from 'stack-utils';
typeof StackUtils;                  // 'function'   ✓
typeof StackUtils.nodeInternals;    // was undefined → now 'function' ✓
typeof StackUtils.prototype?.clean; // was undefined → now 'function' ✓
new StackUtils();                   // was TypeError: undefined is not iterable → now OK ✓

Root cause

The class could not be hoisted out of the CJS wrap IIFE: the #2310 guard refuses to lift a class that references an IIFE-local binding (hoisting would sever the closure → Undefined variable in update expression). With the class trapped inside the IIFE, the module's default degraded to the opaque export default _cjs (the IIFE result), so compile.rs never registered class identity. The consumer then got a value whose statics, .prototype, and closure were all gone.

stack-utils trips this because its class body reads top-level consts as bare identifiers (natives, cwd, re, methodRe), unlike the textbook module.exports = class {} shape which hoists cleanly.

Fix

When the single module.exports = <Ident> target is a top-level class that did not hoist, and the body has no top-level return, drop the IIFE and run the CommonJS body at ESM module scope. The class becomes a real top-level declaration (export default <Class> resolves to it with full identity), and every sibling top-level binding it closes over stays in scope.

Because the class and its bindings now sit at the same (module) scope, this also supersedes the #2310 IIFE-retention mitigation for the default-export-class case — the mutable-closure shape keeps working:

// ws/lib/sender.js shape — verified byte-identical to Node
let pointer = 0;
class Sender { static next() { return pointer++; } }
module.exports = Sender;        // next() → 0, 1, 2 ✓  (and statics are now reachable cross-module)

Details

• New top_level_class_names / source_has_top_level_return helpers gate the flat path. The latter tracks only {/} depth (matching the sibling collect_top_level_let_const_var_names) so a regex literal's brackets can't mis-flag a function-body return as top-level.
• The CommonJS runtime preamble is factored into a shared cjs_preamble string; the IIFE template embeds it verbatim, leaving existing output byte-for-byte unchanged.
• Flat emission triggers only for the previously-broken non-hoisting case, so packages that already hoisted (or that keep the IIFE for a top-level return) are unaffected.

Testing

• cargo test -p perry cjs_wrap — 64 pass (4 new + the Codegen: module-level let mutated via ++/-- inside a nested fn in a cjs-wrapped module → 'Undefined variable in update expression' #2310 test updated to assert the new, better behavior).
• Behavioral parity with node --experimental-strip-types confirmed for: real stack-utils@2.0.6, the ws/sender mutable-let shape, and package-free cross-module module.exports = class.

Out of scope (pre-existing, separate)

Surfaced while verifying, not part of the method-table-absence this fixes:

• A cross-module class instance method reading a module-level const returns garbage (compiled-package instance methods not callable (dayjs.format, chalk.green) — prototype-method dispatch gap #838 family).
• require('module').builtinModules is a partial stub (so StackUtils.nodeInternals().length is smaller than Node's, but the method itself is now present and callable).

Closes #4933.